home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 2003 June / macformat-130.iso / mac / Reviewed⁄Demos / Spearhead Demo / demota / pak1.pk3 / global / ai.scr < prev    next >
Encoding:
Text File  |  2002-10-21  |  58.4 KB  |  2,616 lines
  1. //    Enemy Spawning system created by Mackey McCandlish.
  2. //    
  3. //    Before level waittill prespawn "exec global/ai.scr".
  4. //    
  5. //    Used in many levels.
  6. //    
  7. //    Place an enemy, give him targetname "enemyspawner", preferrably a classname of "ai_actor" so his bounding box is blue in
  8. //    the editor. If you want him to not charge at the player at spawn, set his #playerseek to 0. 
  9. //
  10. //    You can make him run to a specific destination by creating a pathnode with targetname "enemyspawnerdestination" and giving
  11. //    both the node and the spawner the same #group value. Don't give any other spawner/node pair the same #group value.
  12. //
  13. //    Give the node and spawner the same #set value (doesn't have to be the same as the #group value).
  14. //
  15. //    You can create a trigger_multiple with targetname "enemyspawnertrigger" to set off the spawning. Give it the same #set value
  16. //    as whichever spawners you want it to set off. Or you can do "thread global/ai.scr::spawn #" where # is the #set value you
  17. //    want to set off.
  18. //
  19. //    You can do "thread global/ai.scr::spawngroup #1 #2" where #1 is the #set value you want to set off and #group is the group
  20. //    value you want to set off.
  21. //
  22. //    You can set off spawners multiple times, but each trigger only can set them off once.
  23. //
  24. //
  25. //    07/02/2002 (Jeff Leggett)
  26. //        Added new function DeleteEnemySpawner.
  27. //        pass it the targetname and the set # to delete.
  28. //        (note: Use the enemyname parameter for the AI that is being spawned in to set its targetname.)
  29. //
  30. main:
  31. level waittill prespawn
  32.     if (level.bombnum == NIL)
  33.         level.bombnum = 0
  34.  
  35.     // auto-matically setup all friendlies that are spawned in to use the friendly.scr script.  If you don't want
  36.     // this to happen, set this to 0
  37.     level.auto_friendly = 1
  38.     /*
  39.     local.ent = $("t2")
  40.     println ("%%%%%%%%%%%%%%% " + local.ent.team)
  41.     */
  42.  
  43.     local.newset = 3152930
  44.     if ($enemyspawnertrigger)
  45.     for (local.i=1;local.i<$enemyspawnertrigger.size+1;local.i++)
  46.     {
  47.         if ($enemyspawnertrigger[local.i].target)
  48.         {
  49.             $enemyspawnertrigger[local.i].set = local.newset
  50.             local.string = $enemyspawnertrigger[local.i].target
  51.             local.ent = $($enemyspawnertrigger[local.i].target)
  52.             $enemyspawnertrigger[local.i].target = ""
  53.  
  54. //            println ("0size is " + $(local.string).size)
  55.     
  56.             local.counter = 0
  57.             while ((local.ent.size == 1) && !(local.ent.team) && (local.counter < 50))
  58.             {
  59.                 local.counter++
  60.                 local.newent = $(local.ent.target)
  61.                 local.ent.targetname = "enemyspawnertrigger"
  62.                 local.ent.set = local.newset
  63.                 local.string = local.ent.target
  64.                 local.ent.target = ""
  65. //                println ("target will be " + local.string)
  66.                 local.ent = local.newent
  67. //                println ("1size is " + $(local.string).size)
  68.             }
  69.  
  70.             for (local.p=1;local.p<local.ent.size+1;local.p++)
  71.                 local.ent[local.p].set = local.newset
  72.  
  73. //                println ("2size is " + $(local.string).size)
  74.         
  75.             local.breaker = 0
  76.             while ($(local.string).size > 0)
  77.             {
  78. //                println ("3size is " + $(local.string).size)
  79.                 if ($(local.string).size == 1)
  80.                 {
  81.                     $(local.string).set = local.newset
  82.                     $(local.string).targetname = "enemyspawner"    
  83.                 }
  84.                 else
  85.                 if (local.ent[1])
  86.                 {
  87.                     local.ent[1].set = local.newset
  88.                     local.ent[1].targetname = "enemyspawner"
  89.                 }
  90.             }
  91.  
  92. /*
  93.             local.ent = $(local.ent[1].targetname)
  94.             local.ent.targetname = "enemyspawner"
  95.             local.ent.set = local.newset
  96. */
  97.         }
  98.         else
  99.         println "no target"
  100.         local.newset++
  101.     }
  102.  
  103.     if ($enemyspawnertrigger == NULL)
  104.         level.enemyspawnertriggers = 0
  105.         else
  106.         level.enemyspawnertriggers = $enemyspawnertrigger.size
  107.  
  108.     if (level.enemyspawnertriggers > 0)
  109.     {
  110.         level.enemyspawnertrigger = exec global/makearray.scr $enemyspawnertrigger
  111.  
  112.         for (local.i=1;local.i<level.enemyspawnertriggers+1;local.i++)
  113.         {
  114.  
  115.             if (level.enemyspawnertrigger[local.i].thread)
  116.                 println ("TRIGGER HAS THREAD " + level.enemyspawnertrigger[local.i].thread)
  117.             else
  118.                 println "TRIGGER HAD NO THREAD"
  119.  
  120.  
  121.             if (level.enemyspawnertrigger[local.i].set == NIL)
  122.                 exec global/error.scr ("Error, enemyspawnertrigger at " + level.enemyspawnertrigger[local.i].origin + " has no #set") 1
  123.             else
  124.             {
  125.                 if (getcvar(debug) == "1")
  126.                     println ("Spawned enemyspawnertrigger with #set " + level.enemyspawnertrigger[local.i].set)
  127.                 level.enemyspawnertrigger[local.i] thread enemyspawnertrigger
  128.             }
  129.  
  130.         }
  131.         println ("Spawned " + level.enemyspawnertriggers + " enemyspawnertriggers")
  132.     }
  133.  
  134.  
  135.     if ($enemyspawnerdestination == NULL)
  136.         level.enemyspawnerdestinations = 0
  137.         else
  138.         level.enemyspawnerdestinations = $enemyspawnerdestination.size
  139.  
  140.     if (level.enemyspawnerdestinations > 0)
  141.     {
  142.         level.enemyspawnerdestination = exec global/makearray.scr $enemyspawnerdestination
  143.  
  144.         for (local.i=1;local.i<level.enemyspawnerdestinations+1;local.i++)
  145.         {
  146.             if (level.enemyspawnerdestination[local.i].set == NIL)
  147.                 exec global/error.scr ("Error, enemyspawnerdestination at " + level.enemyspawnerdestination[local.i].origin + " has no #set") 1
  148.  
  149.             if (level.enemyspawnerdestination[local.i].group == NIL)
  150.                 exec global/error.scr ("Error, enemyspawnerdestination at " + level.enemyspawnerdestination[local.i].origin + " has no #group") 1
  151.         }
  152.  
  153.         println ("Spawned " + level.enemyspawnerdestinations + " enemyspawnerdestinations")
  154.     }
  155.  
  156.  
  157.     if ($ai_respondspawn == NULL)
  158.         level.ai_respondspawns = 0
  159.         else
  160.         level.ai_respondspawns = $ai_respondspawn.size
  161.  
  162.     if (level.ai_respondspawns > 0)
  163.     {
  164.         level.ai_respondspawn = exec global/makearray.scr $ai_respondspawn
  165.  
  166.         for (local.i=1;local.i<level.ai_respondspawns+1;local.i++)
  167.         {
  168.             level.ai_respondspawn delete
  169.         }
  170.  
  171. //        println ("Spawned " + level.ai_respondspawns + " ai_respondspawns")
  172.         exec global/error.scr ("ERROR, ai_respondspawn is no longer supported. Use alarmnode/threads to spawn traditionally instead") 1
  173.  
  174.     }
  175.  
  176.     if ($ai_trigger == NULL)
  177.         level.ai_triggers = 0
  178.         else
  179.         level.ai_triggers = $ai_trigger.size
  180.  
  181.     if (level.ai_triggers > 0)
  182.     {
  183.         level.ai_trigger = exec global/makearray.scr $ai_trigger
  184.  
  185.         for (local.i=1;local.i<level.ai_triggers+1;local.i++)
  186.         {
  187.             if (level.ai_trigger[local.i].set == NIL)
  188.                 exec global/error.scr ("Error, ai_trigger at " + level.ai_trigger[local.i].origin + " has no #set") 1
  189.                 else
  190.                 {
  191.                     level.ai_triggerused[level.ai_trigger[local.i].set] = 0
  192.                     println ("Spawned ai_trigger " + local.i)
  193.                     level.ai_trigger[local.i] thread ai_trigger
  194.                 }
  195.         }
  196.         println ("Spawned " + level.ai_triggers + " ai_triggers")
  197.     }
  198.  
  199.     if ($ai_location == NULL)
  200.         level.ai_locations = 0
  201.         else
  202.         level.ai_locations = $ai_location.size
  203.  
  204.     if (level.ai_locations > 0)
  205.     {
  206.         level.ai_location = exec global/makearray.scr $ai_location
  207.  
  208.         for (local.i=1;local.i<level.ai_locations+1;local.i++)
  209.             if (level.ai_location[local.i].set == NIL)
  210.                 exec global/error.scr ("Error, ai_location at " + level.ai_location[local.i].origin + " has no #set") 1
  211.  
  212.         println ("Spawned " + level.ai_locations + " ai_location")
  213.     }
  214.  
  215.     if ($ai_speaker == NULL)
  216.         level.ai_speakers = 0
  217.         else
  218.         level.ai_speakers = $ai_speaker.size
  219.  
  220.     if (level.ai_speakers > 0)
  221.     {
  222.         level.ai_speaker = exec global/makearray.scr $ai_speaker
  223.  
  224.         for (local.i=1;local.i<level.ai_speakers+1;local.i++)
  225.             if (level.ai_speaker[local.i].set == NIL)
  226.                 exec global/error.scr ("Error, ai_speaker at " + level.ai_speaker[local.i].origin + " has no #set") 1
  227.  
  228.         println ("Spawned " + level.ai_speakers + " ai_speakers")
  229.     }
  230.  
  231.  
  232.  
  233.  
  234.  
  235.     println ("There are " + $friendlyspawner.size + " friendlyspawners")
  236.  
  237.     if ($friendlyspawner == NULL)
  238.         level.friendlyspawners = 0
  239.         else
  240.         level.friendlyspawners = $friendlyspawner.size
  241.  
  242.     if (level.friendlyspawners > 0)
  243.     {
  244.         level.currentfriendlies = 0
  245.         level.maxfriendlies = 0
  246.  
  247.         level.friendlyspawner = exec global/makearray.scr $friendlyspawner
  248.  
  249.         for (local.i=1;local.i<level.friendlyspawners+1;local.i++)
  250.             level.friendlyspawner[local.i] = waitthread global/spawner.scr::spawner_create level.friendlyspawner[local.i]
  251.  
  252. // local.variable_for_returned_spawner = waitthread global/spawner.scr::spawner_create $dude
  253.  
  254. // local.dude_spawned = waitthread global/spawner.scr::spawner_activate $targetname_of_spawner
  255.  
  256.  
  257.         thread friendlyspawner
  258.  
  259.         println ("Spawned " + level.friendlyspawners + " friendlyspawners")
  260.  
  261.     }
  262.  
  263.     if ($areaspawner == NULL)
  264.         level.areaspawners = 0
  265.         else
  266.         level.areaspawners = $areaspawner.size
  267.  
  268.     if (level.areaspawners > 0)
  269.     {
  270.         level.areaspawner = exec global/makearray.scr $areaspawner
  271.  
  272.         for (local.i=1;local.i<level.areaspawners+1;local.i++)
  273.         {
  274.             
  275.             if (level.areaspawner[local.i].model == NIL)
  276.                 exec global/error.scr ("Error, areaspawner at " + level.areaspawner[local.i].origin + " has no model") 1
  277.  
  278.             if (level.areaspawner[local.i].area == NIL)
  279.                 exec global/error.scr ("Error, areaspawner at " + level.areaspawner[local.i].origin + " has no #area") 1
  280.  
  281.                 local.area = level.areaspawner[local.i].area
  282.  
  283.             level.areaspawner[local.i] = waitthread global/spawner.scr::spawner_create level.areaspawner[local.i]
  284.             level.areaspawner[local.i].area = local.area
  285.  
  286.         }
  287.  
  288.         println ("Spawned " + level.areaspawners + " areaspawners")
  289.         thread areaspawner
  290.     }
  291.  
  292.     if ($fortalarm == NULL)
  293.         level.fortalarms = 0
  294.         else
  295.         level.fortalarms = $fortalarm.size
  296.  
  297.     if (level.fortalarms > 0)
  298.     {
  299.         level.fortalarm = exec global/makearray.scr $fortalarm
  300.  
  301.         for (local.i=1;local.i<level.fortalarms+1;local.i++)
  302.         {
  303.             if (level.fortalarm[local.i].set == NIL)
  304.                 exec global/error.scr ("Error, fortalarm at " + level.fortalarm[local.i].origin + " has no #set") 1
  305.         }
  306.  
  307.         println ("Spawned " + level.fortalarms + " fortalarms")
  308.     }
  309.  
  310.  
  311.     if ($ai_respond == NULL)
  312.         level.ai_responds = 0
  313.         else
  314.         level.ai_responds = $ai_respond.size
  315.  
  316.     if (level.ai_responds > 0)
  317.     {
  318.         level.ai_respond = exec global/makearray.scr $ai_respond
  319.  
  320.         for (local.i=1;local.i<level.ai_responds+1;local.i++)
  321.         {
  322.             if (level.ai_respond[local.i].set == NIL)
  323.                 exec global/error.scr ("Error, ai_respond at " + level.ai_respond[local.i].origin + " has no #set") 1
  324.                 else
  325.                     level.ai_respond[local.i] thread ai_respondthread
  326.         }
  327.         println ("Spawned " + level.ai_responds + " ai_responds")
  328.     }
  329.  
  330.     if ($ai_alarm == NULL)
  331.         level.ai_alarms = 0
  332.         else
  333.         level.ai_alarms = $ai_alarm.size
  334.  
  335.     if (level.ai_alarms > 0)
  336.     {
  337.         level.ai_alarm = exec global/makearray.scr $ai_alarm
  338.  
  339.         for (local.i=1;local.i<level.ai_alarms+1;local.i++)
  340.         {
  341.             if (level.ai_alarm[local.i].set == NIL)
  342.                 exec global/error.scr ("Error, ai_alarm at " + level.ai_alarm[local.i].origin + " has no #set") 1
  343.                 else
  344.                     level.ai_alarm[local.i] thread ai_alarmthread
  345.         }
  346.         println ("Spawned " + level.ai_alarms + " ai_alarms")
  347.     }
  348.  
  349.  
  350.     if ($fortfoe == NULL)
  351.         level.fortfoes = 0
  352.         else
  353.         level.fortfoes = $fortfoe.size
  354.  
  355.     if (level.fortfoes > 0)
  356.     {
  357.         level.fortbodys = 0
  358.         level.fortfoe = exec global/makearray.scr $fortfoe
  359.  
  360.         for (local.i=1;local.i<level.fortfoes+1;local.i++)
  361.         {
  362.             level.fortfoe[local.i] thread fortfoegen
  363.  
  364.             if (level.fortfoe[local.i].set == NIL)
  365.                 exec global/error.scr ("Error, fortfoe at " + level.fortfoe[local.i].origin + " has no #set") 1
  366.         }
  367.  
  368.         println ("Spawned " + level.fortfoes + " fortfoes")
  369.     }
  370.  
  371.  
  372.  
  373.     if ($fortfriend == NULL)
  374.         level.fortfriends = 0
  375.         else
  376.         level.fortfriends = $fortfriend.size
  377.  
  378.     if (level.fortfriends > 0)
  379.     {
  380.         level.fortfriend = exec global/makearray.scr $fortfriend
  381.  
  382.         for (local.i=1;local.i<level.fortfriends+1;local.i++)
  383.             level.fortfriend[local.i] thread deaththread
  384.  
  385. //        thread fortfriend
  386.  
  387.         println ("Spawned " + level.fortfriends + " fortfriends")
  388.     }
  389. //    level waittill spawn
  390.  
  391.     if ($enemyspawner == NULL)
  392.         level.enemyspawners = 0
  393.         else
  394.         level.enemyspawners = $enemyspawner.size
  395.  
  396.     if (level.enemyspawners > 0)
  397.     {
  398.         level.enemyspawner = exec global/makearray.scr $enemyspawner
  399.  
  400.         for (local.i=1;local.i<level.enemyspawners+1;local.i++)
  401.         {
  402.             
  403.             if (level.enemyspawner[local.i].enemyname == NIL)
  404.             {
  405.                 //println "No enemy name!"
  406.                 level.enemyspawner[local.i].enemyname = -1
  407.             }
  408.  
  409.             if (level.enemyspawner[local.i].playerseek == NIL)
  410.                 level.enemyspawner[local.i].playerseek = 1
  411.  
  412.             if (level.enemyspawner[local.i].model == NIL)
  413.                 exec global/error.scr ("Error, enemyspawner at " + level.enemyspawner[local.i].origin + " has no model") 1
  414.  
  415.             if (level.enemyspawner[local.i].set == NIL)
  416.                 exec global/error.scr ("Error, enemyspawner at " + level.enemyspawner[local.i].origin + " has no #set") 1
  417.             else
  418.                 local.set = level.enemyspawner[local.i].set
  419.  
  420.             if (level.enemyspawner[local.i].group == NIL)
  421.             {
  422.                 // jsl-->unnecessary warning message
  423.                 // println ("Warning, enemyspawner at " + level.enemyspawner[local.i].origin + " has no #group")
  424.                 local.group = -1
  425.             }
  426.             else
  427.                 local.group = level.enemyspawner[local.i].group
  428.  
  429.             local.enemyname = level.enemyspawner[local.i].enemyname
  430.             local.playerseek = level.enemyspawner[local.i].playerseek
  431.             
  432.             level.enemyspawner[local.i] = waitthread global/spawner.scr::spawner_create level.enemyspawner[local.i]
  433. //            println ("this is " + level.enemyspawner[local.i].set)
  434.             
  435.  
  436.             level.enemyspawner[local.i].enemyname = local.enemyname
  437.             level.enemyspawner[local.i].playerseek = local.playerseek
  438.             
  439.             if (local.set)
  440.                 level.enemyspawner[local.i].set = local.set
  441.             
  442.             if (local.group)
  443.                 level.enemyspawner[local.i].group = local.group
  444.         }
  445.  
  446.         local.healthtotal = 0
  447.         for (local.i=1;local.i<level.enemyspawners+1;local.i++)
  448.         {
  449.             if ((level.enemyspawner[local.i].nohealth == NIL) || (level.enemyspawner[local.i].nohealth != 1))
  450.             {
  451.                 local.healthtotal++
  452.                 level.enemyspawner[local.i].nohealth = 0
  453.             }
  454.         }
  455.  
  456.         local.healthtotal = local.healthtotal * 0.25
  457. //        println (local.healthtotal + " AI Spawners will drop health")
  458.  
  459.         while (local.healthtotal > 0)
  460.         {
  461.             local.num = randomint (level.enemyspawners) + 1
  462.             if (level.enemyspawner[local.num].nohealth == 0)
  463.             {
  464.                 level.enemyspawner[local.num].nohealth = -1
  465.                 local.healthtotal--
  466.             }
  467.         }
  468.  
  469.         println ("Spawned " + level.enemyspawners + " enemyspawners")
  470.  
  471.     }
  472.  
  473.  
  474.     for (local.i=1;local.i<$dogspawn.size + 1;local.i++)
  475.     {    
  476.         level.dogs = 1
  477.         if ($dogspawn[local.i].set != NIL)
  478.         {
  479.             local.ent = spawn script_origin
  480.             local.ent.origin = $dogspawn[local.i].origin
  481.             local.ent.set = $dogspawn[local.i].set
  482.             level.dogspawner[local.i] = local.ent
  483.             $dogspawn[local.i] thread killself
  484.         }
  485.         else
  486.         println ("dogspawn at " + $dogspawn[local.i].origin + " has no #set")
  487.     }
  488.  
  489.  
  490. /*
  491.     while (1)
  492.     {
  493.         println ("There are " + $friendlyspawner.size + " friendlyspawners")
  494.         wait 1
  495.     }
  496. */
  497.  
  498.     /*
  499.  
  500.     while (1)
  501.     {
  502.         for (local.i=1;local.i<level.enemyspawners+1;local.i++)
  503.         {
  504.  
  505.             if (level.enemyspawner[local.i].fnum != NIL)
  506.                 println ("spawner" + local.i + "'s fnum is " + level.enemyspawner[local.i].fnum)
  507.             else
  508.                 println ("spawner" + local.i + " has no fnum")
  509.  
  510.             if (level.enemyspawner[local.i].health != NIL)
  511.                 println ("spawner" + local.i + "'s health is " + level.enemyspawner[local.i].health)
  512.             else
  513.                 println ("spawner" + local.i + " has no health")
  514.  
  515.  
  516.  
  517.         }
  518.  
  519.  
  520.         wait 1
  521.  
  522.     }
  523.     */
  524.  
  525. end
  526.  
  527. killself:
  528.     wait 1
  529.     self delete
  530.  
  531. end
  532.  
  533. spawndog local.set local.healthnum:
  534.     if (level.spawneddogs == NIL)
  535.         level.spawneddogs = 0
  536.  
  537.     for (local.i=1;local.i<level.dogspawner.size+1;local.i++)
  538.     {
  539.         if (level.dogspawner[local.i].set == local.set)
  540.         {
  541.             local.ent = spawn animal/german_shepherd.tik "targetname" "spawned_dog"
  542.             local.ent.origin = level.dogspawner[local.i].origin
  543.             level.spawneddogs++
  544.             local.ent thread dogattack
  545.             local.ent thread dogdeath
  546.             if (local.healthnum != NIL)
  547.                 local.ent.health = local.healthnum
  548.         }
  549.     }
  550. end
  551.  
  552. dogdeath:
  553.     self waittill death
  554.     level.spawneddogs--
  555. end
  556.  
  557. dogattack:
  558.     self forceactivate
  559.     while (isalive self)
  560.     {
  561.         println ("dog is at " + self.origin + " with thinkstate " + self.thinkstate)
  562.         if (level.dogs == 1)
  563.             self attackplayer
  564.  
  565.         wait 5
  566.     }
  567. end
  568.  
  569.  
  570.  
  571. deaththread:
  572.     if (self.setthread == NIL)
  573.     end
  574.  
  575.     self waittill death
  576.     thread level.script::self.setthread
  577. end
  578.  
  579.  
  580. foealarm:
  581. //    println ("-*-*- " + self + " saw somebody!")
  582.     local.seen = 0
  583.     if (self cansee $player)
  584.     {
  585.         self exec global/disable_ai.scr
  586.         self lookat $player
  587.         wait 2
  588.         if (self cansee $player)
  589.         {
  590.             if (self.alarming == 0)
  591.             {
  592.                 thread setupalarm
  593.                 local.seen = 1
  594.             }
  595.         }
  596.     }
  597.  
  598.     if (local.seen == 0)
  599.     {
  600.         wait 1
  601.         self type_attack "alarm"
  602.         self alarmthread foealarm
  603.     }
  604.  
  605. end
  606.  
  607.  
  608. fortfoegen:
  609.     level waittill spawn
  610.  
  611.     self thread setupalarm
  612.  
  613. //    self alarmthread setupalarm
  614. //    self alarmthread foealarm
  615.     self sight 512
  616.     self hearing 50
  617.     self.alarming = 0
  618.  
  619.  
  620. end
  621.     local.alarmed = 0
  622.     while ((isalive self) && (local.alarmed == 0))
  623.     {
  624.  
  625.         for (local.i=1;local.i<level.fortbodys+1;local.i++)
  626.         {
  627. //            if (sighttrace (self.origin + (0 0 35)) (level.fortbody[local.i].origin + (0 0 35)) 0)
  628.             if (self cansee  (level.fortbody[local.i]))
  629.                 local.alarmed = 1
  630.  
  631.                 wait 0.25
  632.         }        
  633.             wait 0.1
  634.     }
  635.     self.alarming = 1
  636.     if (getcvar(debug) == "1")
  637.         println ("-*-*- " + self + " saw a dead body")
  638.  
  639.     thread forcealarm
  640. end
  641.  
  642. forcealarm:
  643.  
  644.     if (getcvar(debug) == "1")
  645.         println ("Forced Alarm " + self.set)
  646.         local.ent = -1
  647.  
  648.     for (local.i=1;local.i<level.fortalarms+1;local.i++)
  649.     {
  650.         if (level.fortalarm[local.i].set == self.set)
  651.         local.ent = level.fortalarm[local.i]
  652.     }
  653.  
  654.     if (local.ent != -1)
  655.     {
  656.         self exec global/disable_ai.scr
  657.         self runto local.ent
  658.         self waittill movedone
  659.         if (parm.movedone == 1)
  660.             self thread foealarmhit
  661.  
  662.         self exec global/enable_ai.scr
  663.     }
  664. end
  665.  
  666. setupalarm:
  667.  
  668.     if (getcvar(debug) == "1")
  669.         println ("Setting up alarm " + self.set)
  670.  
  671.         local.ent = -1
  672.  
  673.     for (local.i=1;local.i<level.fortalarms+1;local.i++)
  674.     {
  675.         if (level.fortalarm[local.i].set == self.set)
  676.         local.ent = level.fortalarm[local.i]
  677.     }
  678.  
  679.     if (local.ent != -1)
  680.     {
  681.         self type_attack "alarm"
  682.         self alarmthread foealarmhit
  683.         self alarmnode local.ent
  684.     }
  685. end
  686.  
  687.  
  688. foealarmhit:
  689. /*
  690.     local.ent = -1
  691.  
  692.     for (local.i=1;local.i<level.fortalarms+1;local.i++)
  693.     {
  694.         if (level.fortalarm[local.i].set == self.set)
  695.         local.ent = level.fortalarm[local.i]
  696.     }
  697.  
  698.     if (local.ent != -1)
  699.     {
  700.         if (getcvar(debug) == "1")
  701.             println ("-*-*- " + self + " is running to sound the alarm")
  702.         
  703.         self exec global/disable_ai.scr
  704.         self runto local.ent
  705.  
  706.         self alarmthread ai_alarm_fired
  707.         self type_attack "alarm"
  708.  
  709.         while (parm.movedone == 0)
  710.         {
  711.             self runto local.ent
  712.             waittill movedone
  713.         }
  714.         self exec global/enable_ai.scr
  715.  
  716. */
  717.     if (getcvar(debug) == "1")
  718.         println ("Setting OFF alarm " + self.set)
  719.  
  720.     if (self.setthread)
  721.         thread level.script::self.setthread
  722.     thread spawn self.set
  723.     end
  724.  
  725.  
  726.     if (level.fortflag[self.set] == NIL)
  727.         level.fortflag[self.set] = 0
  728.  
  729.     for (local.i=1;local.i<level.fortfriends+1;local.i++)
  730.     {
  731.         if ((level.fortfriend[local.i].set == self.set) && (level.fortflag[self.set] != 1))
  732.             level.fortfriend[local.i] thread spawnfortfriend
  733.  
  734.     }
  735.  
  736.     if (level.fortflag[self.set] == 0)
  737.     {
  738.         level.fortflag[self.set] = 1
  739.         if (self.setthread != NIL)
  740.             thread level.script::self.setthread
  741.     }
  742. //    }
  743.  
  744. //        self exec global/enable_ai.scr
  745.         self runto $player
  746.     
  747. end
  748.  
  749. spawnfortfriend:
  750.     self runto $player
  751.     self waittill death
  752.     if (self.setthread != NIL)
  753.         thread level.script::self.setthread
  754. end
  755.  
  756. spawngroup local.set local.group local.enemyname:
  757.     thread spawn local.set NIL NIL NIL local.group local.enemyname
  758. end
  759.  
  760. //-----------------------------------------------------------
  761. spawnset local.set local.enemyname local.get_there:
  762. //
  763. //    set local.get_there to 1 to have the ai not turn on until
  764. //  he gets to his destination
  765. //    
  766. //-----------------------------------------------------------
  767.  
  768. //    setcvar g_scripttrace 1
  769.  
  770.  
  771.     if ( local.get_there==NIL )
  772.         local.get_there = 0
  773.  
  774.     waitthread spawn local.set NIL NIL NIL NIL local.enemyname local.get_there
  775.  
  776. //    setcvar g_scripttrace 0
  777.  
  778. end
  779.  
  780. spawn local.set local.pause local.thread local.off local.group local.enemyname local.get_there:
  781.  
  782.     if (game.medic != NIL)
  783.         end
  784.  
  785.     if ( local.get_there==NIL )
  786.         local.get_there = 0
  787.  
  788.     if (getcvar(debug) == "1")
  789.         println ("ai.scr spawned " + local.set)
  790.  
  791.     if (local.pause != NIL)
  792.         wait local.pause
  793.  
  794.     local.nSpawned = 0
  795.  
  796.     for (local.i=1;local.i<level.enemyspawners+1;local.i++)
  797.     {
  798.         local.num = 0
  799.  
  800.         if (local.group != NIL)
  801.         {
  802.             if ((level.enemyspawner[local.i].set == local.set) && (level.enemyspawner[local.i].group == local.group))
  803.                 local.num = 1
  804.         }
  805.         else
  806.             if (level.enemyspawner[local.i].set == local.set)
  807.                 local.num = 1
  808.  
  809.         if (local.num == 1)
  810.         {
  811.             if (getcvar(debug) == "1")
  812.             {
  813.                 if (level.enemyspawner[local.i].area != NIL)
  814.                     println ("spawned an enemy with area " + level.enemyspawner[local.i].area)
  815.                 else
  816.                     println ("spawned an enemy with no area")
  817.  
  818.             }
  819.  
  820.             if (level.totalbaddies == NIL)
  821.                 level.totalbaddies = 1
  822.                 else
  823.                 level.totalbaddies++
  824.  
  825.             local.ent = waitthread global/spawner.scr::spawner_activate level.enemyspawner[local.i]
  826.  
  827.             local.nSpawned++
  828.             if (level.enemyspawner[local.i].enemyname != -1)
  829.             {
  830.                 // println "Assigning targetname:" level.enemyspawner[local.i].enemyname
  831.                 local.ent.targetname = level.enemyspawner[local.i].enemyname
  832.             }
  833.             else
  834.             {
  835.                 if ( local.enemyname!=NIL )
  836.                 {
  837.                     local.ent.targetname    = local.enemyname
  838.                     println "spawned with enemyname: " local.enemyname
  839.                 }
  840.                 else
  841.                 {
  842.                     if (level.script == "maps/m1l1.scr")
  843.                         local.ent.targetname = "m1l1_baddie"
  844.                 }
  845.             }
  846.  
  847.             if (level.enemyspawner[local.i].area != NIL)
  848.             {
  849.                 local.ent.area = level.enemyspawner[local.i].area
  850.                 local.ent thread global/friendly.scr::areatrigger
  851.             }
  852.  
  853.             if (level.enemyspawner[local.i].fnum != NIL)
  854.                 level.enemyfnum[level.enemyspawner[local.i].fnum] = local.ent
  855.  
  856.             local.ent.origin = level.enemyspawner[local.i].origin
  857.             local.ent.creator = level.enemyspawner[local.i]
  858.             
  859.             if ((level.dontdropweapons != NIL) && (level.dontdropweapons == 1))
  860.                 local.ent dontdropweapons
  861.  
  862.             local.ent forceactivate
  863.             local.ent thread enemyspawned local.off local.get_there
  864.             local.ent thread deathcheck
  865.  
  866.             if (local.ent.thread != NIL)
  867.                 local.ent thread level.script::local.ent.thread
  868.  
  869.             if (local.thread != NIL)
  870.                 local.ent thread level.script::local.thread
  871.  
  872.             if (level.enemyspawner[local.i].nohealth == -1)
  873.                 level.enemyspawner[local.i].nohealth = -2
  874.  
  875.             if (level.enemyspawner[local.i].nohealth == 0)
  876.                 level.enemyspawner[local.i].nohealth = -2
  877.         }
  878.     }
  879.  
  880. //    println "spawn count: " local.nSpawned " for set #" local.set
  881.  
  882. end
  883.  
  884. alarmspawn local.set local.pause local.alarmthread local.alarmnode local.extra:
  885.  
  886.     if (local.pause != NIL)
  887.         wait local.pause
  888.  
  889.     for (local.i=1;local.i<level.enemyspawners+1;local.i++)
  890.     {
  891.         if (level.enemyspawner[local.i].set == local.set)
  892.         {
  893.             if (getcvar(debug) == "1")
  894.                 println "spawned an enemy"
  895.  
  896.             if (level.totalbaddies == NIL)
  897.                 level.totalbaddies = 1
  898.                 else
  899.                 level.totalbaddies++
  900.  
  901.             local.ent = waitthread global/spawner.scr::spawner_activate level.enemyspawner[local.i]
  902.             local.ent.targetname = "enemyspawnguy"
  903.  
  904. //            local.ent = spawn level.enemyspawner[local.i].spawn_model "targetname" "enemyspawnguy"
  905.             local.ent.origin = level.enemyspawner[local.i].origin
  906.             local.ent.creator = level.enemyspawner[local.i]
  907.             local.ent type_idle "idle"
  908.  
  909.             if ($player istouching $endtriggergun)
  910.             {
  911.                 local.ent type_attack "alarm"
  912.                 local.ent alarmnode local.alarmnode
  913.                 local.ent alarmthread local.alarmthread
  914.             }
  915.             else
  916.             local.ent type_attack "turret"
  917.  
  918.             local.ent forceactivate
  919.             local.ent thread enemyspawned
  920.             local.ent thread deathcheck
  921.  
  922.             if ((local.extra != NIL) && (local.extra == 1) && ($player istouching $endtrigger))
  923.             {
  924.                 local.ent.health = 250
  925.                 local.ent.accuracy = 100
  926.                 local.ent type_attack "turret"
  927.             }
  928.         }
  929.     }
  930.  
  931. end
  932.  
  933.  
  934. deathcheck:
  935.         
  936.     self waittill death
  937.     level.totalbaddies--
  938. end
  939.  
  940.  
  941.  
  942. enemyspawnertrigger:
  943.  
  944.     level waittill spawn
  945.  
  946.     if (getcvar(notrigger) == "1")
  947.     {
  948.         wait 4
  949.         self delete
  950.         end
  951.     }
  952.  
  953.     if (game.medic != NIL)
  954.         end
  955.  
  956.     if (self.friendly != NIL)
  957.     {
  958.         local.break = 0
  959.         while (local.break == 0)
  960.         {
  961.             
  962.             self waittill trigger
  963.  
  964.             if ((parm.other == $player) || (parm.other.targetname == "friendly"))
  965.             {
  966.                 if (getcvar(debug) == "1")
  967.                     println (parm.other + " set off the trigger")
  968.             
  969.         for (local.i=1;local.i<level.enemyspawnertriggers+1;local.i++)
  970.         if ((level.enemyspawnertrigger[local.i]) && (level.enemyspawnertrigger[local.i].set == self.set) && (level.enemyspawnertrigger[local.i] != self))
  971.             level.enemyspawnertrigger[local.i] delete
  972.  
  973.                 thread spawn self.set
  974.                 local.break = 1
  975.             }
  976.             wait 0.5
  977.         }
  978.     }
  979.     else
  980.     {
  981.         println ("origin " + self.origin)
  982.         self waittill trigger
  983.         if (getcvar(debug) == "1")
  984.             println (parm.other + " set off the triggerB")
  985.  
  986.         for (local.i=1;local.i<level.enemyspawnertriggers+1;local.i++)
  987.         if ((level.enemyspawnertrigger[local.i]) && (level.enemyspawnertrigger[local.i].set == self.set) && (level.enemyspawnertrigger[local.i] != self))
  988.             level.enemyspawnertrigger[local.i] delete
  989.  
  990.         thread spawn self.set
  991.     }
  992.  
  993.     if (self.thread)
  994.     {
  995.         self thread level.script::self.thread
  996. //        println ("TRIGGER RAN THREAD " + self.thread)
  997.     }
  998. //    else
  999. //        println "TRIGGER HAD NO THREAD"
  1000.  
  1001.     self delete
  1002.  
  1003.     
  1004.  
  1005. end
  1006.  
  1007.  
  1008.  
  1009. areaspawner:
  1010.     level waittill spawn
  1011.     end
  1012.     local.range = 7750
  1013.     local.minrange = 1000
  1014.     local.spawn = -1
  1015.     level.currentspawnedenemies = 0
  1016.  
  1017.     if (level.maxspawnedenemies == NIL)
  1018.         level.maxspawnedenemies = -1
  1019.     
  1020.     if (getcvar(nospawn) == "1")
  1021.         end
  1022.  
  1023.     while (1)
  1024.     {
  1025.         while (level.currentspawnedenemies < level.maxspawnedenemies)
  1026.         {
  1027.             local.last = -1
  1028.             local.spawn = -1
  1029.             for (local.i=1;local.i<level.areaspawners+1;local.i++)
  1030.             {
  1031.                 if (level.enemyarea[level.areaspawner[local.i].area] !=  0)
  1032.                 if !($player canseenoents level.areaspawner[local.i].origin)
  1033.                 {
  1034. //                    println (vector_length ($player.origin - level.areaspawner[local.i].origin))
  1035.                     local.newrange = vector_length ($player.origin - level.areaspawner[local.i].origin)
  1036.                     if ((local.newrange < local.range) && (local.newrange > local.minrange))
  1037.                     {
  1038.                         local.last = local.spawn
  1039.                         local.range = local.newrange
  1040.                         local.spawn = local.i
  1041.  
  1042.                     }
  1043.                     wait 0.25
  1044.                 }
  1045.  
  1046.                 if (local.last != -1)
  1047.                     local.spawn = local.last
  1048.  
  1049.                 if (local.spawn != -1)
  1050.                 {
  1051.                     if (getcvar(debug) == "1")
  1052.                         println ("spawned area number " + level.currentspawnedenemies)
  1053.                     level.bombnum++
  1054.                     local.bombnum = level.bombnum + 35617
  1055.                     level.currentspawnedenemies++
  1056.             
  1057.                     spawn level.areaspawner[local.spawn].spawn_model "targetname" ("areaspawned_" + local.bombnum)
  1058.                     $("areaspawned_" + local.bombnum).origin = level.areaspawner[local.spawn].origin
  1059.                     $("areaspawned_" + local.bombnum) type_idle "idle"
  1060.                     $("areaspawned_" + local.bombnum) type_attack "cover"
  1061.                     $("areaspawned_" + local.bombnum) forceactivate
  1062.                     $("areaspawned_" + local.bombnum) thread areathink
  1063.                     local.i = level.areaspawners+5
  1064.                 }
  1065.             }
  1066.  
  1067.             wait (8 + randomfloat(8))
  1068.         }
  1069.         
  1070.         wait 3
  1071.     }
  1072.  
  1073. end
  1074.  
  1075. dthink:
  1076.     self waittill death
  1077.     level.currentspawnedenemies--
  1078. end
  1079.  
  1080.  
  1081. areathink:
  1082.     thread dthink
  1083.     self.health = 80
  1084.     wait 2
  1085.     self runto $player
  1086.     self waittill movedone
  1087.     while (isalive self)
  1088.     {
  1089.         self runto $player
  1090.         self waittill movedone
  1091.     }
  1092. end
  1093.  
  1094.  
  1095. hudprint local.string local.r local.g local.b:
  1096.  
  1097.     println local.string
  1098.     if ((level.hudprint != -1) && (level.hudprint != NULL))
  1099.         level.hudprint delete
  1100.  
  1101.     level.hudprint = local
  1102.     local.hudelement = 187
  1103.  
  1104.     if (local.r == NIL)
  1105.         local.r = 1
  1106.  
  1107.     if (local.g == NIL)
  1108.         local.g = 1
  1109.  
  1110.     if (local.b == NIL)
  1111.         local.b = 1
  1112.  
  1113.  
  1114.  
  1115.     local.distance = local.string.size / -2
  1116. //    huddraw_rect local.hudelement (local.distance * 13) 100 0 0
  1117.     huddraw_rect local.hudelement (local.distance * 10) 200 0 0
  1118.     huddraw_color local.hudelement local.r local.g local.b
  1119.  
  1120.  
  1121.     huddraw_font local.hudelement "facfont-20"
  1122.     huddraw_string local.hudelement local.string
  1123.     huddraw_align local.hudelement center top
  1124.     local.strength = 1
  1125.     huddraw_alpha local.hudelement local.strength
  1126.  
  1127.  
  1128.  
  1129.     wait (2 * level.newtimescale)
  1130.     while (local.strength > 0)
  1131.     {
  1132.         local.strength = local.strength - 0.02
  1133.         huddraw_alpha local.hudelement local.strength
  1134.         wait 0.02
  1135.     }
  1136.  
  1137.  
  1138. end
  1139.  
  1140.  
  1141. killtheplayer:
  1142.     while ($player.health > 0)
  1143.         waitframe
  1144.  
  1145.     local.timer = level.time
  1146.     local.newtime = 0
  1147.     while (local.newtime < 1.4)
  1148.     {
  1149.         local.newtime = (level.time - local.timer)
  1150.         waitframe
  1151.     }
  1152.  
  1153.     waitframe
  1154. //    setcvar cg_3rd_person "0"
  1155.     level.3rd_person = 0
  1156.     setcvar "medic_over" "1"
  1157.     setcvar timescale 1
  1158.     exec global/missioncomplete.scr m5l2a
  1159.  
  1160. end
  1161.  
  1162. medic_over:
  1163.     if (getcvar(medic_over) == "1")
  1164.     {
  1165.         game.medic = NIL
  1166. //        setcvar cg_3rd_person "0"
  1167.         level.3rd_person = 0
  1168.         waitframe
  1169.         setcvar timescale 1
  1170.         exec global/missioncomplete.scr m5l2a
  1171.         end        
  1172.     }
  1173.  
  1174.     while (level.medic_searching == NIL)
  1175.     {
  1176.         if (getcvar(medic_over) == "1")
  1177.         {
  1178.             game.medic = NIL
  1179. //            setcvar cg_3rd_person "0"
  1180.             level.3rd_person = 0
  1181.             waitframe
  1182.             setcvar timescale 1
  1183.             exec global/missioncomplete.scr m5l2a
  1184.             end        
  1185.         }
  1186.         wait 0.4
  1187.     }
  1188. end
  1189.  
  1190. origin_thread:
  1191.     level.ender = $player.origin
  1192.  
  1193.     local.range = 0.7
  1194.     while (1)
  1195.     {
  1196.         $player.origin = ($player.origin * local.range) + (level.ender * (1 - local.range))
  1197.         waitframe
  1198.     }
  1199. end
  1200.  
  1201. 3rd_person:
  1202. // huh
  1203.     local.nextview = level.time + 15
  1204.     local.view = 0
  1205.     local.dist = 220 // 170
  1206.  
  1207.     while (level.3rd_person != 1)
  1208.         waitframe
  1209.     
  1210.     thread origin_thread
  1211.  
  1212.     while (level.3rd_person == 1)
  1213.     {
  1214.         if (level.medic != -1)
  1215.         if (level.3rd_person == 1)
  1216.         {
  1217.             if (level.time > local.nextview)
  1218.             {
  1219.                 local.view++
  1220.                 local.nextview = level.time + 25 
  1221.             }
  1222.  
  1223.             if (local.view > 1)
  1224.                 local.view = 0
  1225.  
  1226.  
  1227.             local.org = (level.medic.origin - level.medic.playerend.origin)
  1228.             local.org = vector_normalize (local.org)
  1229.  
  1230.             if (local.view == 0)
  1231.                 local.org = local.org * local.dist
  1232.             else
  1233.                 local.org = local.org * (local.dist * -1)
  1234.  
  1235.             local.org[2] = local.dist / 4 // 2    
  1236.             local.org = local.org + level.medic.origin
  1237.  
  1238. //            local.org = angles_toleft (level.medic.angles)
  1239. //            local.org[1] = local.org[1] * -1
  1240. //            local.org[2] = local.org[2] * -1
  1241. //            local.org2 = ((local.org * local.dist) + (level.medic.origin) + (0 0 local.dist))  
  1242. //            local.org = ((local.org * 30) + (level.medic.origin))
  1243. //            local.end = trace local.org local.org2 1
  1244.  
  1245.             local.end = trace level.medic.origin local.org 1
  1246.             local.vect = (local.end - level.medic.origin)
  1247.             local.vect = vector_normalize (local.vect)
  1248.             local.vect = local.vect * 45 + local.end
  1249.             level.ender = local.end
  1250.  
  1251.             local.angles = vector_toangles ( level.medic.origin - $player.origin)
  1252.  
  1253.  
  1254.             $player.viewangles = local.angles
  1255.             local.angles = $player.viewangles
  1256.  
  1257. //            if (local.view != 0)
  1258. //                local.angles[1] = local.angles[1] + 180
  1259.  
  1260.             local.angles[0] = 15 // 25
  1261.             $player.viewangles = local.angles
  1262.         }
  1263.         waitframe
  1264.     }
  1265.  
  1266.     while (1)
  1267.     {
  1268.         local.org = (level.medic.playerend.origin - level.medic.origin)
  1269.         local.org = vector_normalize (local.org)
  1270.  
  1271.         local.org = local.org * local.dist
  1272.  
  1273.         local.org[2] = local.dist / 2
  1274.         local.org = local.org + level.medic.playerend.origin
  1275.  
  1276.         local.end = trace level.medic.playerend.origin local.org 1
  1277.         local.vect = (local.end - level.medic.playerend.origin)
  1278.         local.vect = vector_normalize (local.vect)
  1279.         local.vect = local.vect * 45 + local.end
  1280.         level.ender = local.end
  1281.  
  1282.         local.angles = vector_toangles ( level.medic.origin - local.end)
  1283.  
  1284.         $player.viewangles = local.angles
  1285.         local.angles = $player.viewangles
  1286.         local.angles[0] = 25
  1287.         $player.viewangles = local.angles
  1288.         waitframe
  1289.     }
  1290.  
  1291. end
  1292.  
  1293. medichunt:
  1294.  
  1295.     level.3rd_person = 0
  1296.     level.medic = -1
  1297.     thread 3rd_person
  1298.     thread medic_over    
  1299.     thread savetheplayer
  1300.     thread killtheplayer
  1301.     
  1302.  
  1303.     $player.gothim = -1
  1304.     thread timescalemover 
  1305.  
  1306.     level.newtimescale = 0.9999
  1307. //    thread medicdance
  1308.  
  1309.  
  1310.     local.medicstart = $player.origin
  1311.  
  1312.     local.playerstartnum = randomint (level.friendlyspawners) + 1
  1313.  
  1314.     if (getcvar(debug) == "1")
  1315.         println ("Playerstartnum was " + local.playerstartnum)
  1316.  
  1317.     local.playerstart = level.friendlyspawner[local.playerstartnum]
  1318.     level.hudprint = -1
  1319.     thread hudprint " " 0.1 1 0.1
  1320.  
  1321.     $player glue local.playerstart 0
  1322.     $player physics_off
  1323.     wait 3
  1324. //    setcvar cg_3rd_person 0
  1325.     level.3rd_person = 0
  1326.  
  1327.     thread hudprint "You have 60 seconds to find a safe hiding spot.."
  1328.     wait 4
  1329.     thread hudprint ".. and then Bazooka-Med will be on your trail!"
  1330.     wait 4
  1331.     thread hudprint "ready" 1 0 0
  1332.     wait 2
  1333.     thread hudprint "set" 1 1 0
  1334.     wait 2
  1335.     thread hudprint "GO!!" 0 1 0
  1336.     $player unglue
  1337.     $player physics_on
  1338.     wait 0.5
  1339.     level.crumbs = 0
  1340.     thread crumb
  1341.     wait 1.5
  1342.     local.timer = 60
  1343.  
  1344.     
  1345.  
  1346.     while (local.timer > 0)
  1347.     {
  1348.         thread hudprint local.timer
  1349.         thread crumb
  1350.         wait 1
  1351.         local.timer--
  1352.     }
  1353.  
  1354. //    local.medicstart = local.playerstart
  1355. //    while (local.medicstart == local.playerstart)
  1356. //        local.medicstart = level.friendlyspawner[(randomint (level.friendlyspawners)) + 1]
  1357.  
  1358.  
  1359.     local.medic = spawn "human/1st-ranger_medic.tik"
  1360.     local.medic.playerend = spawn human/1st-ranger_captain.tik
  1361. //    local.medic.playerend model "player/american_army.tik"
  1362.     local.medic.playerend.no_idle = 1
  1363.     local.medic.playerend exec global/disable_ai.scr
  1364.     local.medic.playerend lookat local.medic
  1365.     local.medic.playerend anim "thompson_crate_standtocrouch"
  1366.     local.medic.playerend.origin = $player.origin
  1367.     local.medic.playerend droptofloor
  1368.     local.medic.playerstartnum = local.playerstartnum
  1369.     local.medic.playerend thread playerenddie
  1370.  
  1371.     local.medic exec global/disable_ai.scr
  1372.     local.medic nodamage
  1373.     local.medic.origin = local.medicstart
  1374.     local.medic thread medichuntthink
  1375.     local.medic item weapons/bazooka.tik    
  1376.     local.medic.weapon = "Bazooka"
  1377.     level.medic = local.medic
  1378.  
  1379.     $player nodamage
  1380.     $player notsolid
  1381. //    $player glue local.medic
  1382.     $player physics_off
  1383.     $player hide
  1384. //    $player model "fx/dummy.tik"
  1385. //    setcvar cg_3rd_person 1
  1386.     level.3rd_person = 1
  1387.  
  1388. end
  1389.  
  1390. playerenddie:
  1391.     while (isalive self)
  1392.         wait 1
  1393.  
  1394.     local.num = randomint(5)
  1395.     if (local.num == 0)
  1396.         thread hudprint "Nice try, please drive through." 1 0.1 0.1
  1397.     else
  1398.     if (local.num == 1)
  1399.         thread hudprint "Nice try, come again." 1 0.1 0.1
  1400.     else
  1401.     if (local.num == 2)
  1402.         thread hudprint "You lose. Hide better." 1 0.1 0.1
  1403.     else
  1404.     if (local.num == 3)
  1405.         thread hudprint "So close, yet so very, very far.." 1 0.1 0.1
  1406.     else
  1407.         thread hudprint "Thou art ownt, medicstyle." 1 0.1 0.1
  1408.  
  1409.  
  1410.     wait 5
  1411.     game.medic = 0
  1412.     level.3rd_person = 0
  1413.     setcvar "medic_over" "1"
  1414.     setcvar timescale 1
  1415.     exec global/missioncomplete.scr m5l2a
  1416. end
  1417.  
  1418. savetheplayer:
  1419.     while (game.medic != NIL)
  1420.         wait 0.5
  1421.  
  1422.     $player.watchmedic = 5
  1423. //    $player solid
  1424. //    $player unglue
  1425.     $player physics_on
  1426.     $player show
  1427. end
  1428.  
  1429.  
  1430.  
  1431. playerwatchesmedic:
  1432.     $player.watchmedic = 0
  1433. //    $player.viewangles = (0 70 0)
  1434.  
  1435.     local.nextview = level.time + 15
  1436.     local.view = 0
  1437.  
  1438.     while ($player.watchmedic == 0)
  1439.     {
  1440.         if (level.time > local.nextview)
  1441.         {
  1442.             local.view++
  1443.             local.nextview = level.time + 25
  1444.         }
  1445.  
  1446.         if (local.view > 1)
  1447.             local.view = 0
  1448.  
  1449.         if (local.view == 0)
  1450.         local.angles = vector_toangles ( self.playerend.origin - self.origin)
  1451.             else
  1452.         if (local.view == 1)
  1453.         local.angles = vector_toangles ( self.origin - self.playerend.origin)
  1454.  
  1455. //        $player.viewangles = local.angles
  1456.         local.angles2 = $player.viewangles
  1457.         local.angles2[0] = 45
  1458. //        $player.viewangles = local.angles2
  1459.         waitframe
  1460.     }
  1461.  
  1462.     if ($player.watchmedic == 5)
  1463.         end
  1464.  
  1465.     while (isalive $player)
  1466.     {
  1467.         local.angles = vector_toangles ( self.origin - $player.origin)
  1468. //        $player.viewangles = local.angles
  1469.         waitframe
  1470.     }
  1471.  
  1472. end
  1473.  
  1474.  
  1475. seeplayer:
  1476.     wait 10
  1477.     while !(self.playerend canseenoents self)
  1478.         wait 0.25
  1479.  
  1480.     self.movedoneradius = 150
  1481.  
  1482.     if (self.medicthink)
  1483.         self.medicthink delete
  1484.  
  1485.     if (self.checkspawns)
  1486.         self.checkspawns delete
  1487.  
  1488.     self.stophunt = 1
  1489.  
  1490.     self.foundcrumb = 2
  1491.  
  1492.     self exec global/stand.scr
  1493.     wait 0.25
  1494.     self lookat self.playerend
  1495.     $player.medicdance stopsound
  1496.     thread hudprint "The Bazooka-Med has you." 0.1 1 0.1
  1497.     $player.gothim = 1
  1498.     waitframe
  1499.     level.newtimescale = 0.9999
  1500.     wait 2
  1501.     $player.watchmedic = 2
  1502.     level.3rd_person = 2
  1503. //    $player unglue
  1504.     $player physics_on
  1505.     $player.origin = self.playerend.origin
  1506. //    self.playerend delete
  1507. //    $player show
  1508. //    $player solid
  1509. //    $player droptofloor
  1510.  
  1511.     wait 0.5
  1512.     local.ent = spawn script_origin
  1513.     local.ent.origin = $player.origin
  1514.     $player glue local.ent
  1515. //    $player physics_off
  1516.     wait 2
  1517.     self accuracy 100
  1518.  
  1519.  
  1520.     self walkto self.playerend
  1521.     self waittill move
  1522.  
  1523.     local.aim = self.playerend gettagposition "bip01 head"
  1524.     local.aim = local.aim + (0 0 -25)
  1525.  
  1526.  
  1527.     self.playerend.health = 5
  1528.     thread playerdie
  1529.     setcvar "medic_over" "1"
  1530.     println "***1***"
  1531.  
  1532.     if (parm.movefail)
  1533.     {
  1534.         self exec global/aimat.scr local.aim
  1535.         wait 0.75
  1536.         local.timer = level.time + 10
  1537.  
  1538.         level.newtimescale = 0.7
  1539.     println "***2***"
  1540.  
  1541.         while ((isalive self.playerend) && (level.time < local.timer))
  1542.         {
  1543.     println "***3***"
  1544.             self exec global/aimat.scr local.aim
  1545.             wait 0.75
  1546.             self exec global/shoot.scr
  1547.             wait 0.5
  1548.         }
  1549.     }
  1550.     else
  1551.     {
  1552.     println "***4***"
  1553.         while (vector_length (self.origin - self.playerend.origin) > 400)
  1554.             wait 0.1
  1555.  
  1556.         while !(self.playerend canseenoents self)
  1557.             wait 0.1
  1558.  
  1559.  
  1560.         self exec global/aimat.scr local.aim
  1561.         wait 0.75
  1562.         level.newtimescale = 0.7
  1563.         local.timer = level.time + 10
  1564.  
  1565.         self exec global/aimat.scr local.aim
  1566.         wait 0.75
  1567.         self exec global/shoot.scr
  1568.         wait 2
  1569.         self exec global/aimat.scr (local.aim + (0 0 35))
  1570.         wait 0.75
  1571.         self exec global/shoot.scr
  1572.         wait 2
  1573.         self walkto self.playerend
  1574.         self waittill movedone
  1575.         self exec global/aimat.scr local.aim
  1576.         wait 0.75
  1577.         self exec global/shoot.scr
  1578.         wait 2
  1579.         self exec global/aimat.scr (local.aim + (0 0 35))
  1580.         wait 0.75
  1581.         self exec global/shoot.scr
  1582.         wait 2
  1583.     println "***5***"
  1584.     }
  1585.  
  1586.     if (isalive self.playerend)
  1587.     {
  1588.     println "***6***"
  1589.         level.newtimescale = 0.99999
  1590.         $player.gothim = 1
  1591.         thread hudprint "Congratulations! Could have sworn he had you.." 0.5 0.8 1.0
  1592.         self takedamage
  1593.         self damage $world 15000 $world (0 0 0) (0 0 0) (0 0 0) 0 9 0 0
  1594.         $player unglue
  1595.         $player physics_on
  1596.  
  1597.         wait 5
  1598.         game.medic = 0
  1599. //        setcvar cg_3rd_person "0"
  1600.         level.3rd_person = 0
  1601.         setcvar "medic_over" "1"
  1602.         setcvar timescale 1
  1603.         exec global/missioncomplete.scr m5l2a
  1604.     }
  1605.  
  1606.  
  1607. end
  1608.  
  1609. playerdie:
  1610.     while (isalive $player)
  1611.         waitframe
  1612.     
  1613.     local.timer = level.time + 1
  1614.     while (local.timer > level.time)
  1615.     {
  1616.         println (local.timer + " " + level.time)
  1617.         level.newtimescale = 0.1
  1618.         waitframe
  1619.     }
  1620.         level.newtimescale = 1
  1621. end
  1622.  
  1623. medichuntthink:
  1624.     
  1625.     level.newtimescale = 0.9999
  1626.     self german
  1627.  
  1628.     thread playerwatchesmedic
  1629.     thread seeplayer
  1630.  
  1631.     self.medicthink = local
  1632.     self notsolid
  1633.     self.movedoneradius = 150
  1634.  
  1635.     self exec global/stand.scr    
  1636.     thread medicdance
  1637.     local.time = level.time + 9
  1638.     /*
  1639.     while (level.time < local.time)
  1640.     {
  1641.         self exec global/stand.scr
  1642.         wait 0.2
  1643.     }
  1644.     */
  1645.  
  1646.     level.medic_searching = 1
  1647.     wait 9
  1648.     thread checkspawns
  1649.     $player.gothim = 0
  1650.     
  1651.  
  1652.     wait 1.5
  1653.     thread hudprint "Ready or not, here I come!" 0.1 0.1 1
  1654.     wait (4 * level.newtimescale)
  1655.     thread hudprint "Good luck" 0.1 0.1 1
  1656.  
  1657.  
  1658. end
  1659.  
  1660. timescalemover:
  1661.  
  1662.     while ($player.gothim == -1)
  1663.     {
  1664.         setcvar timescale level.newtimescale
  1665.         wait 0.5
  1666.     }
  1667.  
  1668.     local.timescale = 2
  1669.  
  1670.     while ((local.timescale < 4) && ($player.gothim == 0))
  1671.     {
  1672.         local.timescale = local.timescale + 0.05
  1673.         setcvar timescale local.timescale
  1674.         level.newtimescale = local.timescale
  1675.         wait 1
  1676.     }
  1677.  
  1678.  
  1679.     while (1)
  1680.     {
  1681.         setcvar timescale 1
  1682.         wait 0.5
  1683.     }
  1684.  
  1685. end
  1686.  
  1687.  
  1688. checkspawns:
  1689.     if (self.stophunt != NIL)
  1690.         end
  1691.  
  1692.     if (self.checkspawns)
  1693.         self.checkspawns delete
  1694.  
  1695.     self.checkspawns = local
  1696.     self.foundcrumb = 0
  1697.     thread crumbcheck
  1698.  
  1699.     for (local.i=1;local.i<level.friendlyspawners+1;local.i++)
  1700.         local.checked[local.i] = 0
  1701.  
  1702.  
  1703.     // local.medic.playerstartnum
  1704.  
  1705.     local.checkedcount = 0
  1706.  
  1707.     local.allfail = 1
  1708.     local.break = 0
  1709.     self.movedoneradius = 80
  1710.     while (local.break == 0)
  1711.     {
  1712.         if (self.stophunt != NIL)
  1713.             end
  1714.  
  1715.         if ((local.checkedcount > 3) && (local.checked[self.playerstartnum] == 0))
  1716.             local.checkthis = self.playerstartnum
  1717.         else
  1718.             local.checkthis = randomint (level.friendlyspawners) + 1
  1719.  
  1720. //        if (local.checkthis == self.playerstartnum)
  1721. //            println "GOING TO PLAYER'S START NOW!!"
  1722.  
  1723. //            local.checkthis = self.playerstartnum
  1724.  
  1725.  
  1726.         if (local.checked[local.checkthis] == 0)
  1727.         {
  1728.             if (getcvar(debug) == "1")
  1729.             {
  1730.                 if (local.checkthis == self.playerstartnum)
  1731.                     println "GOING TO NOW RUNNING TO PLAYER'S START!!"
  1732.                 else
  1733.                     println ("Medic is running to " + level.friendlyspawner[local.checkthis].origin)
  1734.             }
  1735.             self runto level.friendlyspawner[local.checkthis].origin
  1736.             self waittill move
  1737. //            println ("Parm movefail was " + parm.movefail)
  1738.             if !(parm.movefail)
  1739.             {
  1740.                 local.checked[local.checkthis] = 1
  1741.                 local.allfail = 0
  1742.                 self waittill movedone
  1743.                 self exec global/stand.scr
  1744.                 wait ((randomint (4)) + 1)
  1745.                 local.checkedcount++
  1746.  
  1747.             }
  1748.             else
  1749.             {
  1750.                 if (getcvar(debug) == "1")
  1751.                     if (local.checkthis == self.playerstartnum)
  1752.                         println "COULDN'T GET TO PLAYERS START"
  1753.                 
  1754.                 local.checkedcount--
  1755.             }
  1756.  
  1757.         }                
  1758.  
  1759.         local.break = 1
  1760.  
  1761.         for (local.i=1;local.i<level.friendlyspawners+1;local.i++)
  1762.         {
  1763.             if (local.checked[local.i] == 0)
  1764.             {    
  1765. //                println ("Checked " + local.i + " = 0")
  1766.                 local.break = 0
  1767.                 waitframe
  1768.             }
  1769. //            else
  1770. //                println ("Checked " + local.i + " = 1")
  1771.         }
  1772.         wait 0.1
  1773.  
  1774. //            println "GOING TO PLAYER'S START NOW!!"
  1775.  
  1776.     }
  1777.  
  1778.     if (local.allfail == 0)
  1779.         self thread chasethread
  1780.     else
  1781.     {
  1782.         level.newtimescale = 0.99999
  1783.         self.gotthim = 1
  1784.         thread hudprint "Congratulations, you have eluded Bazooka-Med" 0.5 0.8 1.0
  1785.         self takedamage
  1786.         self damage $world 15000 $world (0 0 0) (0 0 0) (0 0 0) 0 9 0 0
  1787.         $player unglue
  1788.         $player physics_on
  1789.  
  1790.         wait 5
  1791.         game.medic = 0
  1792. //        setcvar cg_3rd_person "0"
  1793.         level.3rd_person = 0
  1794.         setcvar "medic_over" "1"
  1795.         setcvar timescale 1
  1796.         exec global/missioncomplete.scr m5l2a
  1797.     }
  1798.  
  1799. end
  1800.  
  1801. crumbcheck:
  1802.     local.startnum = 5000
  1803.     if (self.stophunt != NIL)
  1804.         end
  1805.  
  1806.     while (self.foundcrumb == 0)
  1807.     {
  1808.     
  1809.         local.vect = vector_length (self.origin - level.crumb[1].origin)
  1810.         if (local.vect < local.startnum)
  1811.         {
  1812.             local.startnum = local.vect
  1813. //            println ("*********** " + local.vect)
  1814.         }
  1815.     
  1816.         if (vector_length (self.origin - level.crumb[1].origin) < 450)
  1817.         {
  1818.             self.foundcrumb = 3
  1819.             if (self.medicthink)
  1820.                 self.medicthink delete
  1821.  
  1822.             if (self.checkspawns)
  1823.                 self.checkspawns delete
  1824.  
  1825.             self thread chasethread
  1826.  
  1827.             end
  1828.         }
  1829.  
  1830.         wait 0.1
  1831.     }
  1832.  
  1833. end
  1834.  
  1835. chasethread:
  1836.     self.foundcrumb = 1
  1837.     local.crumbs = 0
  1838.     local.failed = -1
  1839.     self.movedoneradius = 150
  1840.  
  1841.     while (local.crumbs < level.crumbs)
  1842.     {
  1843.         if (self.stophunt != NIL)
  1844.             end
  1845.  
  1846.         if (self.checkspawns)
  1847.             self.checkspawns delete
  1848.  
  1849.         local.crumbs++
  1850.         self runto level.crumb[local.crumbs]
  1851.         self waittill move
  1852.         if (parm.movefail)
  1853.         {
  1854.             if (local.failed == 0)
  1855.             {
  1856.                  thread hudprint "Bazooka-Med seems to have lost the trail" 0.1 0.1 1
  1857.                 self exec global/stand.scr
  1858.                 wait 3
  1859.             }
  1860.             local.failed = 1
  1861.  
  1862.         }
  1863.         else
  1864.         {
  1865.             self waittill movedone
  1866.             if (local.failed != 0)
  1867.             {
  1868.                 thread hudprint "BAZOOKA-MED HAS THE TRAIL!!" 1 0.1 0.1
  1869.                 local.failed = 0
  1870.                 wait 2
  1871.             }
  1872.         }
  1873.     }
  1874.  
  1875.     if (self.stophunt != NIL)
  1876.         end
  1877.  
  1878.     thread checkspawns
  1879. end
  1880.  
  1881. medicdance:
  1882.     local.ent = spawn script_model
  1883.     local.ent model "fx/dummy.tik"
  1884.     local.ent notsolid
  1885.     local.ent glue $player
  1886.  
  1887.     $player.medicdance = local.ent
  1888.     waitframe
  1889.     local.ent loopsound medicdance 2 "levelwide"
  1890. //    local.ent playsound medicdance volume 2
  1891. //    local.ent waittill sounddone
  1892.     wait 300
  1893.         
  1894.     if ((isalive $player) && ($player.gothim == 0))
  1895.     {
  1896.         level.newtimescale = 0.99999
  1897.         self.gotthim = 1
  1898.         thread hudprint "Congratulations, you have eluded Bazooka-Med" 0.5 0.8 1.0
  1899.         self takedamage
  1900.         self damage $world 15000 $world (0 0 0) (0 0 0) (0 0 0) 0 9 0 0
  1901.         $player unglue
  1902.         $player physics_on
  1903.  
  1904.         wait 5
  1905.         game.medic = 0
  1906. //        setcvar cg_3rd_person "0"
  1907.         level.3rd_person = 0
  1908.         setcvar "medic_over" "1"
  1909.         setcvar    timescale 1
  1910.         exec global/missioncomplete.scr m5l2a
  1911.     }
  1912.  
  1913. end
  1914.  
  1915. crumb:
  1916.     local.ent = spawn script_origin
  1917.     local.ent.origin = $player.origin
  1918.     level.crumbs++
  1919.     level.crumb[level.crumbs] = local.ent
  1920. end
  1921.  
  1922. killfriends:
  1923. //    while (isalive $player)
  1924. //    {
  1925.         for (local.i=1;local.i<$friendly.size+1;local.i++)
  1926.         {
  1927.             if (isalive $friendly[local.i])
  1928.                 $friendly[local.i] thread diedie
  1929.             
  1930.         }
  1931.  
  1932. //    }
  1933. end
  1934.  
  1935. diedie:
  1936.     wait 1
  1937.     self damage $world 15000 $world (0 0 0) (0 0 0) (0 0 0) 0 9 0 0
  1938. end
  1939.  
  1940.  
  1941. friendlyspawner:
  1942.     level waittill spawn
  1943.  
  1944.     if (game.medic != NIL)
  1945.     {
  1946.         for (local.i=1;local.i<level.friendlyspawners+1;local.i++)
  1947.             level.friendlyspawner[local.i] droptofloor
  1948.  
  1949.         thread medichunt
  1950.         thread killfriends
  1951.         end
  1952.     }
  1953.  
  1954.     end
  1955.  
  1956.     local.range = 950
  1957.     local.spawn = -1
  1958.     local.last = -1
  1959.     local.lastspawner = -1
  1960.  
  1961.     if (getcvar(nospawn) == "1")
  1962.         end
  1963.  
  1964.     while (1)
  1965.     {
  1966.         while (level.currentfriendlies < level.maxfriendlies)
  1967.         {
  1968.             local.range = 50000
  1969.             for (local.i=1;local.i<level.friendlyspawners+1;local.i++)
  1970.             {
  1971.                 if (level.friendlyspawner[local.i] != local.lastspawner)
  1972.                 {
  1973.                     local.newrange = vector_length ($player.origin - level.friendlyspawner[local.i].origin)
  1974.                     if (local.newrange < local.range)
  1975.                     {
  1976.                         if !($player canseenoents (level.friendlyspawner[local.i].origin + (0 0 50)))
  1977.                         {
  1978.                             local.last = local.spawn
  1979.                             local.range = local.newrange
  1980.                             local.spawn = local.i
  1981.                             wait 1
  1982.         
  1983. //                            if (getcvar(debug) == "1")
  1984. //                                println ("friendly spawner " + local.i + " is prepping")
  1985.                         }
  1986.                     }
  1987.                 }
  1988.             }
  1989.  
  1990.             if (local.last != -1)
  1991.             local.spawn = local.last
  1992.  
  1993.             if (local.spawn != -1)
  1994.             {
  1995. //                println ("local.spawner is " + local.spawn)
  1996. //                println ("spawned friendly number " + level.currentfriendlies)
  1997.                 level.currentfriendlies++
  1998.                 level.friendlys++
  1999.         
  2000. //                local.ent = spawn level.friendlyspawner[local.spawn].spawn_model "targetname" "friendly"
  2001.                 local.ent = waitthread global/spawner.scr::spawner_activate level.friendlyspawner[local.spawn]
  2002.  
  2003.                 level.friendly[level.friendlys] = local.ent
  2004.                 local.ent.origin = level.friendlyspawner[local.spawn].origin
  2005.                 local.ent waitthread global/friendly.scr::friendlyinit
  2006.                 local.ent type_idle "idle"
  2007.                 local.ent type_attack "cover"
  2008.                 local.ent forceactivate
  2009.                 local.ent thread friendlythink
  2010.                 local.i = level.friendlyspawners+5
  2011.                 local.lastspawner = local.i
  2012.  
  2013.                 if (getcvar(debug) == "1")
  2014.                     println ("friendly spawner " + local.i + " is genning")
  2015.     
  2016.              }
  2017.  
  2018.             wait 2
  2019.         }
  2020.             wait 3
  2021.     }
  2022.  
  2023. end
  2024.  
  2025. friendlydead:
  2026.     self waittill death
  2027.     level.currentfriendlies--
  2028.     for (local.i=1;local.i<level.friendlys+1;local.i++)
  2029.         if (level.friendly[local.i] == self)
  2030.             level.friendly[local.i] = level.deadent
  2031.  
  2032. end
  2033.  
  2034. friendlythink:
  2035.     self exec global/disable_ai.scr
  2036.     self thread friendlydead
  2037.     self threatbias ignoreme
  2038.     self accuracy 3
  2039.     self.health = 100
  2040.     self.maxhealth = 100
  2041.     self.friendtype = 0 // was 0
  2042.     self.mins = -30
  2043.     self.maxs = 50
  2044.     self.distance = 400
  2045.  
  2046.     self runto $player
  2047.     wait 4
  2048.     self exec global/enable_ai.scr
  2049.     self threatbias 0
  2050.     
  2051.     self.movedoneradius = 300
  2052.  
  2053.     while ((isalive self) && (vector_length (self.origin - $player.origin) > 500))
  2054.     {
  2055.         self runto $player
  2056.         self waittill movedone
  2057.         waitframe
  2058.     }
  2059.  
  2060.     if (isalive self)
  2061.     {
  2062.         self.friendtype = 0
  2063.         self thread global/friendly.scr::friendlythink
  2064.     }
  2065.  
  2066. end
  2067.  
  2068.  
  2069. sniperthink:
  2070.     self accuracy 100
  2071.     self threatbias -50
  2072.     self noticescale 1
  2073.  
  2074.  
  2075.     local.ent = spawn script_origin
  2076.     local.ent.origin = self.origin
  2077.     if !(self.target)
  2078.         exec global/error.scr ("ERROR, sniper at " + self.origin + " has no target") 1
  2079.  
  2080.     println "GETTIN READY TO SNIPE"
  2081.     
  2082.     local.mode = 0
  2083.     while (isalive self)
  2084.     {
  2085.         self leash 0
  2086.  
  2087.         if (local.mode == 0)
  2088.         {
  2089.             self exec global/disable_ai.scr
  2090.             self runto self.target
  2091.             self waittill movedone
  2092.             self tether self.target
  2093.             self exec global/enable_ai.scr
  2094.             local.mode = 1
  2095.         }
  2096.         else
  2097.         {
  2098.             self exec global/disable_ai.scr
  2099.             self runto local.ent
  2100.             self waittill movedone
  2101.             self tether local.ent
  2102.             self exec global/enable_ai.scr
  2103.             local.mode = 0
  2104.         }
  2105.         wait (3 + randomint(10))
  2106.     }
  2107.  
  2108.     local.ent delete
  2109.  
  2110. end
  2111.  
  2112. // jsl--> local.get_there means turn off ai so that they get to their target.  Once there, turn ai back on...
  2113. enemyspawned local.off local.get_there:
  2114.  
  2115.  
  2116.     if (self.creator.type != NIL)
  2117.     {
  2118.         if (self.creator.type == "sniper")
  2119.         {
  2120.             self.accuracy = 100
  2121.             self.noticescale = 1
  2122.             self gun KAR98sniper
  2123.             self item weapons/KAR98sniper.tik
  2124.             self gun "KAR98sniper"
  2125.             self useweaponclass rifle
  2126.  
  2127.         }
  2128.     }
  2129.  
  2130.     if ( local.get_there==NIL )
  2131.         local.get_there = 0
  2132.  
  2133. //    self.angles = self.creator.angles
  2134. //    self.angle = self.creator.angle
  2135.  
  2136.     /*
  2137.     if (getcvar(debug) == "1")
  2138.     {
  2139.         if (self.creator.group != NIL)
  2140.         {
  2141.             println ("Group is " + self.creator.group + " and Set is " + self.creator.set)
  2142.         }
  2143.     }
  2144.     */
  2145.  
  2146.     local.targ = NIL
  2147.     if (self.creator.group != -1)
  2148.     {
  2149.         for (local.i=1;local.i<level.enemyspawnerdestinations+1;local.i++)
  2150.         {
  2151.             if ((level.enemyspawnerdestination[local.i].group == self.creator.group) && (level.enemyspawnerdestination[local.i].set == self.creator.set))
  2152.             {
  2153.                 if (getcvar(debug) == "1")
  2154.                     println (self + " spawned and is running to " + self.creator.set + "/" + self.creator.group)
  2155.                 local.targ = level.enemyspawnerdestination[local.i]
  2156.             }
  2157.         }
  2158.     }
  2159.     else
  2160.     if (self.creator.spawn_target != "")
  2161.     {
  2162.         local.targ = $(self.creator.spawn_target)
  2163. //        println ("local.targ is " + local.targ + " and creator target is " + self.creator.target)
  2164. //        println (" oh and local.targ's origin is " + local.targ.origin)
  2165.     }
  2166.  
  2167.  
  2168.     if (self.creator.pause != NIL)
  2169.         wait self.creator.pause
  2170.  
  2171.  
  2172.     if ((local.targ != NIL) && (local.targ != NULL))
  2173.     {
  2174.         local.break = 0
  2175.  
  2176. //        self tether local.targ
  2177.  
  2178.         local.disabledAI = 0
  2179.  
  2180.         if (self.type_attack == "balcony_attack" || level.disableAI==1)
  2181.         {
  2182.             local.disabledAI = 1
  2183.             exec global/disable_ai.scr
  2184.         }
  2185.  
  2186.         if ( local.get_there==1 )
  2187.         {
  2188. //            dprintln self.targetname ": running to target with AI off!"
  2189.             self exec global/disable_ai.scr
  2190.         }
  2191.  
  2192.         while (local.break == 0)
  2193.         {
  2194.             if (isalive self)
  2195.             {
  2196.                 self runto local.targ
  2197.                 self waittill movedone
  2198.  
  2199. //                if (parm.movedone == 1)
  2200.                 if (vector_length (self.origin - local.targ.origin) < 80)
  2201.                     local.break = 1
  2202.                 else
  2203.                     wait 1
  2204.             }
  2205.             else
  2206.                 local.break = 1
  2207.         }
  2208.  
  2209.         if ( local.get_there==1 && isAlive self )
  2210.         {
  2211. //            dprintln self.targetname ": got there, turning ai back on!!!"
  2212.             self exec global/enable_ai.scr
  2213.         }
  2214.  
  2215.         self tether local.targ
  2216.  
  2217.         if (local.disabledAI==1)
  2218.             exec global/enable_ai.scr
  2219.  
  2220.         if (getcvar(debug) == "1")
  2221.             println (self + " ran to and reached " + self.creator.set + "/" + self.creator.group)
  2222.     }
  2223.  
  2224.     if (isalive self)
  2225.     if (self.team == $player.team)
  2226.     {
  2227.         if ( level.auto_friendly==1 )
  2228.         {
  2229.             level.friendlys++
  2230.             level.friendly[level.friendlys] = self
  2231.             if (self.creator.fnum)
  2232.             {
  2233.                     println ("*fnum 1")
  2234.                 if !(level.fnum[self.creator.fnum])
  2235.                 {
  2236.                     level.fnum[self.creator.fnum] = self
  2237.                     println ("*fnum 2")
  2238.                 }
  2239.             }
  2240.                     println ("*fnum 3")
  2241.  
  2242.             self.targetname = "friendly"
  2243.             self thread global/friendly.scr::friendlythink
  2244.             self.friendtype = 0
  2245.         }
  2246.         end
  2247.     }
  2248.     
  2249.     println "..........................."
  2250.  
  2251.  
  2252. //    println ("playerseek is " + self.creator.playerseek)
  2253.  
  2254.     if (self.creator.playerseek != 0)
  2255.         self.nosurprise = 1
  2256.  
  2257.  
  2258.     /*
  2259.     if (isalive self)
  2260.     if (self.team == $player.team)
  2261.     {
  2262.         level.friendlys++
  2263.         level.friendly[level.friendlys] = self
  2264.         self.targetname = "friendly"
  2265.         self thread global/friendly.scr::friendlythink
  2266.         self.friendtype = 0
  2267.         end
  2268.     }
  2269.     */
  2270.     
  2271.     if (self.creator.playerseek == 1)
  2272.     {
  2273.  
  2274.         local.ent = spawn script_origin
  2275.         local.ent.origin = self.origin
  2276.         if (local.off != NIL)
  2277.         {
  2278.             self exec global/disable_ai.scr
  2279.             self.nosurprise = 1
  2280. //            self hearing 0
  2281. //            self sight 0
  2282.         }
  2283.  
  2284.         while (isalive self)
  2285.         {
  2286.             self runto $player
  2287.  
  2288.             if (local.off != NIL)
  2289.             {
  2290.                 wait local.off
  2291.                 self exec global/enable_ai.scr
  2292.                 self exec global/aimat.scr $player
  2293. //                self sight 2500
  2294. //                self hearing 2500
  2295.                 local.off = NIL
  2296.             }
  2297.  
  2298.             self waittill movedone
  2299.  
  2300.             self runto local.ent
  2301.             self waittill movedone
  2302.             waitframe
  2303.         }
  2304.  
  2305.         local.ent delete
  2306.  
  2307.     }
  2308.     else
  2309.     if (self.creator.playerseek == 2)
  2310.     {
  2311.  
  2312.         local.range = randomint(250) + 350
  2313.         self.movedoneradius = local.range - 35
  2314.         self exec global/disable_ai.scr
  2315.         while ((isalive self) && (vector_length (self.origin - $player.origin) > local.range))
  2316.         {
  2317.             self runto $player
  2318.             self waittill movedone
  2319.             waitframe
  2320.         }
  2321.  
  2322.         self exec global/enable_ai.scr
  2323.  
  2324.         while ((isalive self) && (self.thinkstate != "attack"))
  2325.         {
  2326.             self runto $player
  2327.             self waittill movedone
  2328.             waitframe
  2329.         }
  2330.  
  2331.     }
  2332.     else
  2333.     if (self.creator.playerseek == 3)
  2334.     {
  2335.         wait 3.5
  2336.  
  2337.         while ((isalive self) && (self.thinkstate != "attack"))
  2338.         {
  2339.             self runto $player
  2340.             self waittill movedone
  2341.             waitframe
  2342.         }
  2343.  
  2344.     }
  2345.  
  2346.     
  2347. end
  2348.  
  2349.  
  2350. /*        
  2351.     self notsolid
  2352.     level waittill spawn
  2353.     if (self.model == NIL)
  2354.         self.model = "human/german_wehrmact_soldier.tik"
  2355.     self.spawn_model = self.model
  2356.     self.model = "fx/dummy.tik"
  2357.     self.shouldbreathsteam = self.breathsteam
  2358.     self.breathsteam = 0
  2359.     if (getcvar(debug) == "1")
  2360.         println (self + " has model " + self.spawn_model)
  2361. */
  2362.  
  2363. end
  2364.  
  2365.  
  2366. debug:
  2367.     level.frienddebug = 1
  2368. end
  2369.  
  2370. aisound:
  2371.     if (self.pause != NIL)
  2372.         wait self.pause
  2373.  
  2374.     if (self.sound == NIL)
  2375.         self.sound = "airplane"
  2376.  
  2377.     if (getcvar(debug) == "1")
  2378.         println ("playing sound " + self.sound + " at " + self.origin)
  2379.  
  2380.         self playsound self.sound
  2381. end
  2382.  
  2383. ai_trigger:
  2384.     level waittill spawn
  2385.     self waittill trigger
  2386.     if (level.ai_triggerused[self.set] == 0)
  2387.     {
  2388.         if (getcvar(debug) == "1")
  2389.             println "Triggering ai_respond"
  2390.  
  2391.         level.ai_triggerused[self.set] = 1
  2392.         for (local.i=1;local.i<level.ai_speakers+1;local.i++)
  2393.         {
  2394.             if (level.ai_speaker[local.i].set == self.set)
  2395.                 level.ai_speaker[local.i] thread aisound
  2396.         }
  2397.  
  2398.         local.ent = -1
  2399.  
  2400.         for (local.i=1;local.i<level.ai_locations+1;local.i++)
  2401.         {
  2402.             if (self.set == level.ai_location[local.i].set)
  2403.             {
  2404.                 local.ent = level.ai_location[local.i]
  2405.                 local.i = level.ai_locations + 5
  2406.             }
  2407.         }
  2408.  
  2409.         for (local.i=1;local.i<level.ai_alarms+1;local.i++)
  2410.         {
  2411.             if ((isalive level.ai_alarm[local.i]) && (level.ai_alarm[local.i].set == self.set))
  2412.             {
  2413.                 level.ai_alarm[local.i] thread dosound
  2414.             }
  2415.         }
  2416.  
  2417.         for (local.i=1;local.i<level.ai_responds+1;local.i++)
  2418.         {
  2419.             if ((isalive level.ai_respond[local.i]) && (level.ai_respond[local.i].set == self.set))
  2420.             {
  2421.                 level.ai_respond[local.i] thread dosound
  2422.             }
  2423.         }
  2424.  
  2425.         if (getcvar(debug) == "1")
  2426.             println ("local.ent is " + local.ent)
  2427.  
  2428.  
  2429.         if (local.ent != -1)
  2430.         {
  2431.             for (local.i=1;local.i<level.ai_alarms+1;local.i++)
  2432.             {
  2433.                 if (level.ai_alarm[local.i].set == self.set)
  2434.                 {
  2435.                     level.ai_alarm[local.i] thread runtoplayer local.ent
  2436.                 }
  2437.             }
  2438.  
  2439.         }
  2440.  
  2441.  
  2442.     }
  2443.  
  2444. end
  2445.  
  2446. runtoplayer local.ent:
  2447.  
  2448.     local.num = -1
  2449.  
  2450.     if (self.type_idle == "patrol")
  2451.     {
  2452.         local.patrolpath = self.patrolpath
  2453.         local.num = 1
  2454.     }
  2455.  
  2456.     if (isalive self)
  2457.     {
  2458.         if (getcvar(debug) == "1")
  2459.             println (self + " is walking to inspect the sound")
  2460.         local.origin = self.origin
  2461.         self runto local.ent
  2462.         self waittill movedone
  2463.         wait 2
  2464.         self walkto local.origin
  2465.         self waittill movedone
  2466.     }
  2467.  
  2468.     if (local.num == 1)
  2469.     {
  2470.         self type_idle "patrol"
  2471.         self patrolpath local.patrolpath
  2472.     }
  2473.  
  2474. //        self         
  2475.  
  2476. end
  2477.  
  2478. dosound:
  2479.     if (isalive self)
  2480.     {
  2481.         if (self.pause != NIL)
  2482.             wait self.pause
  2483.  
  2484.         if (self.sound != NIL)
  2485.             self playsound self.sound
  2486.     }
  2487. end
  2488.  
  2489.  
  2490. ai_alarmthread:
  2491.         self alarmthread ai_alarm_fired
  2492.         self type_attack "alarm"
  2493. end
  2494.  
  2495.  
  2496. ai_respondspawnthread:
  2497.  
  2498.     self hide
  2499.     self notsolid
  2500. end
  2501.  
  2502. ai_respondthread:
  2503.  
  2504. //    self hide
  2505. //    self notsolid
  2506. end
  2507.  
  2508. ai_alarm_fired:
  2509.  
  2510.         for (local.i=1;local.i<level.ai_respondspawns+1;local.i++)
  2511.         {
  2512.             if (level.ai_respondspawn[local.i].set == self.set)
  2513.             {
  2514.                 level.bombnum++
  2515.                 local.bombnum = level.bombnum + 35617
  2516.  
  2517.                 spawn script_origin "targetname" ("responder_start" + local.bombnum)
  2518.                 $("responder_start" + local.bombnum).origin = level.ai_respondspawn[local.i].origin
  2519.  
  2520.                 if (getcvar(debug) == "1")
  2521.                     println ("model spawning is " + level.ai_respondspawn[local.i].spawn_model)
  2522.  
  2523.                 spawn level.ai_respondspawn[local.i].spawn_model "targetname" ("responder_" + local.bombnum)
  2524.                 $("responder_" + local.bombnum).origin = level.ai_respondspawn[local.i].origin
  2525.                 $("responder_" + local.bombnum) type_idle "idle"
  2526.                 $("responder_" + local.bombnum) type_attack "turret"
  2527.                 $("responder_" + local.bombnum) forceactivate
  2528.                 $("responder_" + local.bombnum).start = $("responder_start" + local.bombnum)
  2529.                 $("responder_" + local.bombnum) thread responder_think
  2530.             }
  2531.         }
  2532.  
  2533.         for (local.i=1;local.i<level.ai_responds+1;local.i++)
  2534.         {
  2535.             if (level.ai_respondspawn[local.i].set == self.set)
  2536.             {
  2537.                 level.bombnum++
  2538.                 local.bombnum = level.bombnum + 3561
  2539.  
  2540.                 spawn script_origin "targetname" ("responder_start" + local.bombnum)
  2541.                 $("responder_start" + local.bombnum).origin = level.ai_respond[local.i].origin
  2542.  
  2543.                 level.ai_respond[local.i] forceactivate
  2544.                 level.ai_respond[local.i].start = $("responder_start" + local.bombnum)
  2545.                 level.ai_respond[local.i] thread responder_think
  2546.             }
  2547.         }
  2548.  
  2549.         self.start = self.origin
  2550.         self thread responder_think
  2551.  
  2552. end
  2553.  
  2554. responder_think:
  2555.     if (self.pause != NIL)
  2556.         wait self.pause
  2557.  
  2558.     if (self.endpoint == NIL)
  2559.         self.endpoint = "player"
  2560.  
  2561.     while (isalive self)
  2562.     {
  2563.         self runto $(self.endpoint)
  2564.         self waittill movedone
  2565.         self runto self.start
  2566.         self waittill movedone
  2567.     }
  2568.         self.start delete
  2569. end
  2570.  
  2571. //                $("responder_" + local.bombnum) exec global/disable_ai.scr
  2572. //                $("responder_" + local.bombnum) patrolpath local.node
  2573.  
  2574. rotatedown local.amount:
  2575.     self rotateydown local.amount
  2576.     self waitmove
  2577. end
  2578.  
  2579. rotateup local.amount:
  2580.     self rotateyup local.amount
  2581.     self waitmove
  2582. end
  2583.  
  2584.  
  2585. //----------------------------------------------------------------------
  2586. DeleteEnemySpawner local.enemyname local.set:
  2587. //
  2588. //    Delete enemy spawners with the passed in enemy name and set number....
  2589. //
  2590. //    Added by Jeff Leggett 7/1/2002
  2591. //
  2592. //----------------------------------------------------------------------
  2593.  
  2594.     if (local.enemyname == NULL)
  2595.     {
  2596.         println "DeleteEnemySpawner: Enemyname is NULL"
  2597.         End
  2598.     }
  2599.  
  2600.     if ( local.enemyname.size<1 )
  2601.     {
  2602.         println "DeleteEnemySpawner: Size<0 for:" local.enemyname
  2603.         End
  2604.     }
  2605.     
  2606.     for (local.i=local.enemyname.size;local.i>0;local.i--)
  2607.     {
  2608.         if ( local.enemyname[local.i].set == local.set )
  2609.         {
  2610.             local.enemyname[local.i] bedead
  2611.             local.enemyname[local.i] delete
  2612.         }
  2613.     }
  2614.  
  2615.     End
  2616.